// 实现一个 flatten 函数，实现如下的转换功能
const obj = {
    a: 1,
    b: [1, 2, { c: true },[3]],
    c: { e: 2, f: 3 },
    g: null,
};
// 转换为 因为嵌套里的key可能重复，可能导致flat出来的对象缺少一些key
let objRes = {
    a: 1,
    "b[0]": 1,
    "b[1]": 2,
    "b[2].c": true,
    "c.e": 2,
    "c.f": 3,
    g: null,
};

let flatten = (obj) => {
    let result = {};
    let process = (key, value) => {
        // 首先判断是基础数据类型还是引用数据类型
        // 如果value本身不是primitive类型，Object(value)会直接返回value的引用，此时Object(value) === value。所以Object(value) !== value成立就是primitive类型
        if (Object(value) !== value) {
            // 基础数据类型
            if (key) {
                result[key] = value;
            }
        }
        // 数组与矩阵
        else if (Array.isArray(value)){
            for (let i = 0; i < value.length; i++) {
                process(`${key}[${i}]`, value[i])
            }
            if (value.length === 0) {
                result[key] = [];
            }
        }
        // 对象
        else {
            console.log(value)
            let objArr = Object.keys(value);
            objArr.forEach(item => {
                // 这里处理了初次进来 key为''的情况
                process(key?`${key}.${item}`:`${item}`, value[item])
            });
            if (objArr.length === 0 && key) {
                result[key] = {};
            }
        }
    }
    process('', obj)
    return result;
}

console.log(flatten(obj));
